package com.hncc.kumao.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.hncc.kumao.entity.OfflineDownloadTask;
import com.hncc.kumao.entity.OfflineDownloadTaskInfo;
import com.hncc.kumao.entity.OfflineDownloadTaskWait;

import redis.clients.jedis.Jedis;

public class OfflineDownloadUtils {
    
    //获取离线下载任务进度
    public static OfflineDownloadTaskInfo getTaskProgressRate(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        String jsonString = jedis.hget(ConstValue.OFFLINE_DOWNLOAD_TASK_PROGRESS_TATE, taskId);
        JedisUtils.closeJedis(jedis);
        OfflineDownloadTaskInfo taskInfo;
        if(jsonString == null || jsonString.trim().length() <= 0) {
            taskInfo = new OfflineDownloadTaskInfo();
            taskInfo.setTaskId("0");
            taskInfo.setTotalSize("0");
            taskInfo.setCurrentSize("0");
            taskInfo.setState(0);
        } else {
            taskInfo = JSON.parseObject(jsonString, OfflineDownloadTaskInfo.class);
        }
        return taskInfo;
    }
    //获取离线下载任务进度
    public static String getTaskProgressRateJson(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        String jsonString = jedis.hget(ConstValue.OFFLINE_DOWNLOAD_TASK_PROGRESS_TATE, taskId);
        JedisUtils.closeJedis(jedis);
        return jsonString;
    }
    //设置离线下载任务进度
    public static void setTaskProgressRate(OfflineDownloadTaskInfo taskInfo) {
        Map map = new HashMap();
        map.put("taskId", taskInfo.getTaskId());
        map.put("currentSize", taskInfo.getCurrentSize());
        map.put("totalSize", taskInfo.getTotalSize());
        map.put("state", taskInfo.getState());
        map.put("createTime", taskInfo.getCreateTime());
        map.put("startTime", taskInfo.getStartTime());
        map.put("endTime", taskInfo.getEndTime());
        String jsonString = JSON.toJSONString(map);
        Jedis jedis = JedisUtils.getJedis();
        jedis.hset(ConstValue.OFFLINE_DOWNLOAD_TASK_PROGRESS_TATE, taskInfo.getTaskId(), jsonString);
        JedisUtils.closeJedis(jedis);
    }
    //删除离线下载任务进度
    public static void removeTaskProgressRate(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.hdel(ConstValue.OFFLINE_DOWNLOAD_TASK_PROGRESS_TATE, taskId);
        JedisUtils.closeJedis(jedis);
    }
    //获取离线下载任务进度状态
    public static Integer getTaskProgressState(String taskId) {
        return getTaskProgressRate(taskId).getState();
    }
    
    //获取用户离线下载任务编号列表
    public static List<String> getUserTaskIdList(String userId) {
        Jedis jedis = JedisUtils.getJedis();
        String jsonString = jedis.hget(ConstValue.USER_OFFLINE_DOWNLOAD_TASK_ID_LIST, userId);
        JedisUtils.closeJedis(jedis);
        if(jsonString == null || jsonString.trim().length() <= 0) {
            return new ArrayList<String>();
        } else {
            String arrayString = JSON.parseObject(jsonString).getString("odTaskId");
            List<String> list = JSON.parseArray(arrayString, String.class);
            return list;
        }
    }
    //设置用户离线下载任务编号列表
    public static void setUserTaskIdList(String userId, List<String> taskIdList) {
        Map map = new HashMap();
        map.put("odTaskId", taskIdList);
        String jsonString = JSON.toJSONString(map);
        Jedis jedis = JedisUtils.getJedis();
        jedis.hset(ConstValue.USER_OFFLINE_DOWNLOAD_TASK_ID_LIST ,userId, jsonString);
        JedisUtils.closeJedis(jedis);
    }
    //添加用户离线下载任务编号列表
    public static void addUserTaskIdList(String userId, String taskId) {
        List<String> list = getUserTaskIdList(userId);
        list.add(taskId);
        setUserTaskIdList(userId, list);
    }
    
    /********************************************************/
    
    //获取正常离线下载任务队列
    public static List<String> getNormalQueue() {
        Jedis jedis = JedisUtils.getJedis();
        List<String> list = jedis.lrange(ConstValue.OFFLINE_DOWNLOAD_NORMAL_QUEUE, 0, -1);
        JedisUtils.closeJedis(jedis);
        return list;
    }
    //获取正常离线下载队列数量
    public static int getNormalQueueNumber() {
        List<String> list = getNormalQueue();
        if(list == null || list.size() <= 0) {
            return 0;
        } else {
            return list.size();
        }
    }
    //获取正常离线下载任务队列中顶端第一个任务ID(该操作会同时移除顶部任务id)
    public static String getNormalQueueTopTaskId() {
        Jedis jedis = JedisUtils.getJedis();
        String topTaskId = jedis.lpop(ConstValue.OFFLINE_DOWNLOAD_NORMAL_QUEUE);
        JedisUtils.closeJedis(jedis);
        return topTaskId;
    }
    //向正常离线下载任务队列中添加任务
    public static void addNormalQueue(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.rpush(ConstValue.OFFLINE_DOWNLOAD_NORMAL_QUEUE, taskId);
        JedisUtils.closeJedis(jedis);
    }
    //向正常离线下载任务队列中移除任务
    public static void removeNormalQueue(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.lrem(ConstValue.OFFLINE_DOWNLOAD_NORMAL_QUEUE, 0, taskId);
        JedisUtils.closeJedis(jedis);
    }
    
    //获取正在进行中的正常离线下载任务队列
    public static List<String> getNormalTask() {
        Jedis jedis = JedisUtils.getJedis();
        List<String> list = jedis.lrange(ConstValue.OFFLINE_DOWNLOAD_NORMAL_TASK, 0, -1);
        JedisUtils.closeJedis(jedis);
        return list;
    }
    //获取正在进行中的正常离线下载任务数量
    public static int getNormalTaskNumber() {
        List<String> list = getNormalTask();
        if(list == null || list.size() <= 0) {
            return 0;
        } else {
            return list.size();
        }
    }
    //向正在进行中的正常离线下载任务队列中添加任务
    public static void addNormalTask(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.rpush(ConstValue.OFFLINE_DOWNLOAD_NORMAL_TASK, taskId);
        JedisUtils.closeJedis(jedis);
    }
    //向正在进行中的正常离线下载任务队列中移除任务
    public static void removeNormalTask(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.lrem(ConstValue.OFFLINE_DOWNLOAD_NORMAL_TASK, 0, taskId);
        JedisUtils.closeJedis(jedis);
    }
    
    //获取正常离线下载任务最大并行数量(默认是3)
    public static int getNormalParallelNumber() {
        Jedis jedis = JedisUtils.getJedis();
        String numberString = jedis.get(ConstValue.OFFLINE_DOWNLOAD_NORMAL_PARALLEL_NUMBER);
        JedisUtils.closeJedis(jedis);
        int number;
        try {
            number = Integer.parseInt(numberString);
        } catch (NumberFormatException e) {
            //e.printStackTrace();
            return 3;
        }
        if(numberString == null || numberString.trim().length() <= 0) {
            return 3;
        }  else {
            return number;
        }
    }
    //设置正常离线下载任务最大并行数量
    public static void setNormalParallelNumber(int number) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.set(ConstValue.OFFLINE_DOWNLOAD_NORMAL_PARALLEL_NUMBER, number + "");
        JedisUtils.closeJedis(jedis);
    }
    
    /********************************************************/
    
    //获取重新连接离线下载任务队列
    public static List<String> getRetryQueue() {
        Jedis jedis = JedisUtils.getJedis();
        List<String> list = jedis.lrange(ConstValue.OFFLINE_DOWNLOAD_RETRY_QUEUE, 0, -1);
        JedisUtils.closeJedis(jedis);
        return list;
    }
    //获取重新连接离线下载队列数量
    public static int getRetryQueueNumber() {
        List<String> list = getRetryQueue();
        if(list == null || list.size() <= 0) {
            return 0;
        } else {
            return list.size();
        }
    }
    //获取重新连接离线下载任务队列中顶端第一个任务ID(该操作会同时移除顶部任务id)
    public static String getRetryQueueTopTaskId() {
        Jedis jedis = JedisUtils.getJedis();
        String topTaskId = jedis.lpop(ConstValue.OFFLINE_DOWNLOAD_RETRY_QUEUE);
        JedisUtils.closeJedis(jedis);
        return topTaskId;
    }
    //向重新连接离线下载任务队列中添加任务
    public static void addRetryQueue(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.rpush(ConstValue.OFFLINE_DOWNLOAD_RETRY_QUEUE, taskId);
        JedisUtils.closeJedis(jedis);
    }
    //向重新连接离线下载任务队列中移除任务
    public static void removeRetryQueue(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.lrem(ConstValue.OFFLINE_DOWNLOAD_RETRY_QUEUE, 0, taskId);
        JedisUtils.closeJedis(jedis);
    }
    
    //获取等待中的重新连接离线下载任务队列
    public static List<OfflineDownloadTaskWait> getRetryWait() {
        Jedis jedis = JedisUtils.getJedis();
        Map<String, String> map = jedis.hgetAll(ConstValue.OFFLINE_DOWNLOAD_RETRY_WAIT);
        JedisUtils.closeJedis(jedis);
        List<OfflineDownloadTaskWait> tasklist = new ArrayList<OfflineDownloadTaskWait>();
        if(map != null && map.size() > 0) {
            for (String key : map.keySet()) {
                String jsonString = map.get(key);
                OfflineDownloadTaskWait task = JSON.parseObject(jsonString, OfflineDownloadTaskWait.class);
                tasklist.add(task);
            }
        }
        return tasklist;
    }
    //获取指定等待中的重新连接任务
    public static OfflineDownloadTaskWait getRetryWaitItem(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        String jsonString = jedis.hget(ConstValue.OFFLINE_DOWNLOAD_RETRY_WAIT, taskId);
        JedisUtils.closeJedis(jedis);
        return JSON.parseObject(jsonString, OfflineDownloadTaskWait.class);
    }
    //获取正在等待中的重新连接离线下载任务数量
    public static int getRetryWaitNumber() {
        List<OfflineDownloadTaskWait> list = getRetryWait();
        if(list == null || list.size() <= 0) {
            return 0;
        } else {
            return list.size();
        }
    }
    //向等待中的重新连接离线下载任务队列中添加任务
    public static void addRetryWait(OfflineDownloadTaskWait task) {
        String jsonString = JSON.toJSONString(task);
        Jedis jedis = JedisUtils.getJedis();
        jedis.hset(ConstValue.OFFLINE_DOWNLOAD_RETRY_WAIT, task.getTaskId(), jsonString);
        JedisUtils.closeJedis(jedis);
    }
    //向等待中的重新连接离线下载任务队列中移除任务
    public static void removeRetryWait(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.hdel(ConstValue.OFFLINE_DOWNLOAD_RETRY_WAIT, taskId);
        JedisUtils.closeJedis(jedis);
    }
    
    //获取正在进行中的重新连接离线下载任务队列
    public static List<String> getRetryTask() {
        Jedis jedis = JedisUtils.getJedis();
        List<String> list = jedis.lrange(ConstValue.OFFLINE_DOWNLOAD_RETRY_TASK, 0, -1);
        JedisUtils.closeJedis(jedis);
        return list;
    }
    //获取正在进行中的重新连接离线下载任务数量
    public static int getRetryTaskNumber() {
        List<String> list = getRetryTask();
        if(list == null || list.size() <= 0) {
            return 0;
        } else {
            return list.size();
        }
    }
    //向正在进行中的重新连接离线下载任务队列中添加任务
    public static void addRetryTask(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.rpush(ConstValue.OFFLINE_DOWNLOAD_RETRY_TASK, taskId);
        JedisUtils.closeJedis(jedis);
    }
    //向正在进行中的重新连接离线下载任务队列中移除任务
    public static void removeRetryTask(String taskId) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.lrem(ConstValue.OFFLINE_DOWNLOAD_RETRY_TASK, 0, taskId);
        JedisUtils.closeJedis(jedis);
    }
    
    //获取重新连接离线下载任务最大并行数量(默认是3)
    public static int getRetryParallelNumber() {
        Jedis jedis = JedisUtils.getJedis();
        String numberString = jedis.get(ConstValue.OFFLINE_DOWNLOAD_RETRY_PARALLEL_NUMBER);
        JedisUtils.closeJedis(jedis);
        int number;
        try {
            number = Integer.parseInt(numberString);
        } catch (NumberFormatException e) {
            //e.printStackTrace();
            return 3;
        }
        if(numberString == null || numberString.trim().length() <= 0) {
            return 3;
        }  else {
            return number;
        }
    }
    //设置重新连接离线下载任务最大并行数量
    public static void setRetryParallelNumber(int number) {
        Jedis jedis = JedisUtils.getJedis();
        jedis.set(ConstValue.OFFLINE_DOWNLOAD_RETRY_PARALLEL_NUMBER, number + "");
        JedisUtils.closeJedis(jedis);
    }
    
    //根据当前时间等级获取下一个时间等级
    public static int getNextTimeLevel(int currentTimeLevel) {
        switch (currentTimeLevel) {
        case ConstValue.RETRY_TIME_LEVEL1:
            return ConstValue.RETRY_TIME_LEVEL2;
        case ConstValue.RETRY_TIME_LEVEL2:
            return ConstValue.RETRY_TIME_LEVEL3;
        case ConstValue.RETRY_TIME_LEVEL3:
            return ConstValue.RETRY_TIME_LEVEL4;
        case ConstValue.RETRY_TIME_LEVEL4:
            return ConstValue.RETRY_TIME_LEVEL5;
        case ConstValue.RETRY_TIME_LEVEL5:
            return ConstValue.RETRY_TIME_LEVEL6;
        case ConstValue.RETRY_TIME_LEVEL6:
            return ConstValue.RETRY_TIME_LEVEL7;
        case ConstValue.RETRY_TIME_LEVEL7:
            return ConstValue.RETRY_TIME_LEVEL8;
        case ConstValue.RETRY_TIME_LEVEL8:
            return ConstValue.RETRY_TIME_LEVEL9;
        case ConstValue.RETRY_TIME_LEVEL9:
            return ConstValue.RETRY_TIME_LEVEL10;
        case ConstValue.RETRY_TIME_LEVEL10:
            return ConstValue.RETRY_TIME_LEVEL11;
        case ConstValue.RETRY_TIME_LEVEL11:
            return ConstValue.RETRY_TIME_LEVEL12;
        case ConstValue.RETRY_TIME_LEVEL12:
            return ConstValue.RETRY_TIME_LEVEL13;
        case ConstValue.RETRY_TIME_LEVEL13:
            return ConstValue.RETRY_TIME_LEVEL14;
        case ConstValue.RETRY_TIME_LEVEL14:
            return ConstValue.RETRY_TIME_LEVEL15;
        case ConstValue.RETRY_TIME_LEVEL15:
            return ConstValue.RETRY_TIME_LEVEL16;
        case ConstValue.RETRY_TIME_LEVEL16:
            return ConstValue.RETRY_TIME_LEVEL_END;
        default:
            return ConstValue.RETRY_TIME_LEVEL1;
        }
    }
}
